home *** CD-ROM | disk | FTP | other *** search
/ Ham Radio 2000 #1 / Ham Radio 2000.iso / ham2000 / packet / thenet / x1j4_src / tnl7c.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-08  |  22.1 KB  |  690 lines
  1. /*****************************************************************************/
  2. /*                                              */
  3. /*                                         */
  4. /*    *****              *****                      */
  5. /*     *****            *****                         */
  6. /*       *****          *****                         */
  7. /*         *****        *****                         */
  8. /*  ***************      ***************                     */
  9. /*  *****************    *****************                     */
  10. /*  ***************      ***************                     */
  11. /*         *****        *****       TheNet                    */
  12. /*       *****          *****       Portable. Compatible.         */
  13. /*     *****            *****       Public Domain             */
  14. /*    *****              *****    NORD><LINK                  */
  15. /*                                         */
  16. /* This software is public domain ONLY for non commercial use                */
  17. /*                                                                           */
  18. /*                                         */
  19. /*****************************************************************************/
  20.  
  21. /* Level 7C, Hostinterface                             */
  22. /* Version 1.01                                     */
  23. /* Hans Georg Giese, DF2AU, Hinter dem Berge 5, 3300 Braunschweig         */
  24. /* 02-APR-88                                     */
  25. /* Modified April 1991 G8KBB - use of register keyword
  26.  *                           - use all.h header file
  27.  *                           - host commands for KISS & HOST optional compile
  28.  *                           - optinally remove unneeded esc commands
  29.  *                           - replace many simple operations by assembler
  30.  */
  31.  
  32. /*
  33.  * September 1993 - released as TheNet X-1J
  34.  */
  35.  
  36. #include "all.h"
  37. #include "tntyp.h"        /* Definition der Typen                 */
  38. #include "tnl7ce.h"        /* externe Definitionen                 */
  39.  
  40. /*---------------------------------------------------------------------------*/
  41. VOID hosini()            /* Hostinterface initialisieren             */
  42.   {
  43.   hstusr = &hstubl[0];        /* Pointer auf Kontrollblock setzen         */
  44.  
  45.   hstusr->conflg =        /* Host ist nicht connected             */
  46.   hstusr->disflg =        /* kein Disconnect nach Info-senden         */
  47.   hstusr->inlin =        /* keine Zeilen von Eingabe da             */
  48.   hstusr->outlin =        /* keine Zeilen fuer Ausgabe da             */
  49.   blixfl =            /* Host darf nicht connected werden         */
  50. #ifndef MODIFIED
  51.   hostco =            /* Host darf nicht connected werden         */
  52. #endif
  53.   blicnt = 0;            /* Eingabezeile ist leer                  */
  54.  
  55.   inithd(&hstusr->inbuf);    /* Listenkopf Eingabepuffer initialisieren   */
  56.   inithd(&hstusr->outbuf);    /* Listenkopf Ausgabepuffer initialisieren   */
  57.  
  58.   magicn = MAGIC;        /* Flag fuer Warmstart setzen             */
  59.   }
  60.  
  61. /*---------------------------------------------------------------------------*/
  62. VOID hostsv()            /* Hostinterface Service             */
  63.   {                /* regelmaessig von MAIN aufgerufen         */
  64.   register char    zeichen;    /* Scratch fuer Eingabehandling             */
  65.   register mhtyp *mbuff;    /* Messagebuffer                 */
  66.  
  67.   hstusr = &hstubl[0];        /* Pointer auf Kontrollblock setzen         */
  68. #ifdef HOSTMODE
  69.   if( hstmod && ishost() )
  70.     hstmodsv();
  71. #endif
  72.   hstsen(0);            /* falls Info vorhanden: senden, wenn Platz  */
  73.   if (((hstusr->disflg & 0x80) != 0) /* Disconnect gefordert?             */
  74.      && (hstusr->outlin == 0))    /* und Info gesendet?                 */
  75.      hstdis();            /* dann disconnecten                 */
  76.  
  77.   if (! blicnt && ! blixfl) {    /* Zeile leer und kein X-OFF gekommen?         */
  78.                 /* dann Ausgabe versuchen             */
  79.  
  80.     while (! ishput() && hstusr->outlin != 0)    /* SIO frei und was da?         */
  81.      {
  82.       mbuff = (mhtyp *) unlink(hstusr->outbuf.lnext);    /*Buffer aus Kette   */
  83.       hstusr->outlin -=1;            /* eine Zeile weniger         */
  84.       while (mbuff->getcnt < mbuff->putcnt)    /* Info ausgeben         */
  85.        {
  86.         zeichen = (getchr(mbuff) &0x7f);    /* Zeichen holen         */
  87.         if (zeichen == 0x7f) zeichen = 0x08;    /* RUBOUT wird Backspace     */
  88.  
  89.         if ((zeichen >= ' ') || (zeichen == 0x0a) ||
  90.           (zeichen == 0x07) || (zeichen == 0x09))
  91.           hputc(zeichen);            /* druckbare Zeichen ausgeben*/
  92.  
  93.         else
  94.          {
  95.           if (zeichen == 0x0d)
  96.            {
  97.             hputc(zeichen);            /* CR wird CR-LF         */
  98.             hputc(0x0a);
  99.            }
  100.           else                    /* andere Kontrollzeichen    */
  101.            {
  102.             hputc('^');                /* mit Prefix             */
  103.             hputc(zeichen + '@');
  104.            }
  105.          }
  106.        }
  107.       dealmb(mbuff);        /* Buffer freigeben                 */
  108.       }
  109.     }
  110.   if (ishget() /* == 1 */) {    /* Zeichen von Eingabe bereit?             */
  111.     zeichen = hgetc() & 0x7f;    /* dann holen, ohne Parity             */
  112.     if (! blicnt)        /* erstes Zeichen der Zeile?             */
  113.       blipoi = bline;        /* Pointer auf Anfang setzen             */
  114.  
  115.     switch(zeichen) {
  116.  
  117. /*==============================*/
  118.     case 0x0d:            /* Ende der Zeile                 */
  119.       hputc(zeichen);        /* Echo fuer <CR>                 */
  120.       hputc(0x0a);        /* <LF> anhaengen                 */
  121.       blipoi = bline;        /* Pointer auf Anfang fuer Verarbeitung         */
  122.  
  123.       if ((blicnt != 0)        /* etwas eingegeben?                 */
  124.         && (*blipoi == DEFESC)    /* und erstes Zeichen = <ESC>? dann Befehl   */
  125. #ifdef HOSTMODE
  126.         && ( hstmod == 0 || ( hstmod && (hststs == 0) ) ) )
  127. #else
  128.         )
  129. #endif
  130.         {
  131.           ++blipoi;        /* erstes Zeichen ist verarbeitet         */
  132.           --blicnt;        /* Zahl der Zeichen -1                 */
  133.           hstcmd();        /* Befehl verarbeiten                 */
  134.         }
  135.  
  136.       else            /* Zeile kein Befehl:                 */
  137.         {
  138.           if ((hstusr->conflg != 0) /* Host connected?                 */
  139.             && ((nmbfre > 64)    /* noch Platz im Speicher?             */
  140.             &&  ((hstusr->disflg & 0x80) == 0)))   /* kein DISC eingeleitet? */
  141.             {
  142.                   mbuff = (mhtyp *) allocb();    /* Buffer holen                 */
  143.                   while (blicnt--)    /* Zeile uebertragen             */
  144.                     putchr(*blipoi++, mbuff);
  145.                   putchr('\15', mbuff);/* <CR> anhaengen             */
  146.                   rwndmb(mbuff);    /* alle Bufferpointer wieder auf 0   */
  147.                   relink(mbuff, hstusr->inbuf.lprev); /* in Kette haengen    */
  148.                   ++hstusr->inlin;    /* Zahl der Zeilen +1             */
  149.             }
  150.         }
  151.       blicnt = 0;
  152.       break;
  153.  
  154. /*==============================*/
  155.     case 0x08:            /* Backspace                     */
  156.     case 0x7f:            /* Rubout                     */
  157.       if (blicnt != 0) bliloe(); /* Zeichen loeschen - wenn vorhanden         */
  158.       break;
  159.  
  160. /*==============================*/
  161.     case 0x15:            /* ctl-u = Zeile loeschen             */
  162.     case 0x18:            /* ctl-x = Zeile loeschen             */
  163.       while (blicnt != 0) bliloe(); /* alles killen                 */
  164.       break;
  165.  
  166. /*==============================*/
  167.     case 0x11:            /* X-ON                         */
  168.       blixfl = FALSE;
  169.       break;
  170.  
  171. /*==============================*/
  172.     case 0x13:            /* X-OFF                     */
  173.       blixfl = TRUE;
  174.       break;
  175.  
  176. /*==============================*/
  177.     default:            /* sonstiges Zeichen                 */
  178.       if (blicnt < BLINLEN) {    /* noch Platz in der Zeile?             */
  179.         blieco(zeichen);    /* Echo ausgeben                 */
  180.         *blipoi++ = zeichen;    /* Zeichen in Buffer                 */
  181.         ++blicnt;        /* Zeilenlaenge zaehlen                 */
  182.         }
  183.       else hputc(0x07);        /* kein Platz: meckern!                 */
  184.  
  185.       break;
  186.       }
  187.     }
  188.   }
  189.  
  190. /*---------------------------------------------------------------------------*/
  191. VOID hostim()            /* Host Timerservice                 */
  192.   {                /* Aufruf jede Sekunde von MAIN             */
  193.   hstusr = &hstubl[0];        /* Pointer auf Userblock setzen             */
  194.   if (hstusr->conflg != 0)    /* wenn Host connected                 */
  195.     {
  196.       if ((hstusr->noact2 != 0)    /* und Timeout noch nicht 0             */
  197.         && (--hstusr->noact2 == 0)) /* Timeout runterzaehlen             */
  198.         hstdis();        /* bei 0 abwerfen                 */
  199.     }
  200. #ifdef HOSTMODE
  201.   if( hstmod && (hststs == 3) && ishost() )
  202.     if( --hotout == 0 )
  203.       hststs = 0;
  204. #endif
  205.   }
  206.  
  207. /*---------------------------------------------------------------------------*/
  208. VOID hstreq()            /* Connect Request an Host             */
  209.   {
  210. #ifdef HOSTMODE
  211.   if( hstmod && ishost() )
  212.   {
  213.     if( 
  214. #ifndef MODIFIED
  215.     hostco == 1 && 
  216. #endif
  217. #ifdef PK96
  218.     hststs == 0 && ( CNTLB0 & (1<<5) ) )
  219. #else
  220.     hststs == 0 && ( SIBRR0 & (1<<5) ) )
  221. #endif
  222.     {
  223.       raisedcd();
  224.       hststs = 1;
  225.       hstcon();
  226.     }
  227.     else
  228.       putmsg("Host faulty or unavailable.");
  229.   }
  230.   else
  231.   {
  232. #endif
  233. #ifdef MODIFIED
  234.   hstcon();
  235. #else
  236.   if (hostco == 1) hstcon();    /* ausfuehren, wenn erlaubt             */
  237.   else {            /* sonst anklopfen                 */
  238.     bstrng("\015\012CONNECT REQUEST fm ");
  239.     bcalou(hstusr->call);    /* Call melden                     */
  240.     bbel();            /* bimmeln                     */
  241.     l2tol7(3, hstusr, 0);    /* mit DM nach unten melden             */
  242.     }
  243. #endif
  244.   }
  245. #ifdef HOSTMODE
  246.   }
  247. #endif
  248.  
  249. /*---------------------------------------------------------------------------*/
  250. VOID hstout()            /* Host Interface Timeout             */
  251.   {
  252.   dealml(& hstusr->inbuf);    /* eingegebene Zeilen loeschen             */
  253.   hstusr->inlin = 0;
  254.   hstusr->disflg |= 0x80;    /* Abwurf verlangen                 */
  255.   }
  256.  
  257. /*---------------------------------------------------------------------------*/
  258. BOOLEAN hstrec(conflg, ublk)    /* Info fuer Host zeigen             */
  259. register mhtyp    *ublk;        /* User Kontroll Block                 */
  260. BOOLEAN    conflg;            /* Congestion Flag                 */
  261.   {
  262.   register hustyp *cblk;    /* lokaler Kontrollblock             */
  263.  
  264.   cblk = (hustyp *) ublk->l2lnk;        /* auf Host-Kontollblock     */
  265.  
  266.   if ((conflg /*== 1*/) || (cblk->outlin < conctl)) /* noch Platz ?             */
  267.     {
  268.       relink(unlink(ublk), cblk->outbuf.lprev); /* Buffer umhaengen         */
  269.       ++cblk->outlin;        /* eine Zeile mehr                 */
  270.       cblk->noact2 = ininat;    /* Timeout neu setzen                 */
  271.       return (TRUE);        /* OK, Info ist auf dem Weg             */
  272.     }
  273.   else return (FALSE);        /* Fehler, hat nicht funktioniert         */
  274.   }
  275.  
  276. /*---------------------------------------------------------------------------*/
  277. VOID blieco(zeichen)        /* Echo fuer Hostterminal              */
  278. register char    zeichen;
  279.   {
  280.   if (blicnt == 0 && zeichen == DEFESC && 
  281.      ( hstmod==0 || (hstmod && (hststs == 0) )))  /* erstes Zeichen und <ESC>? */
  282.     bstrng("* ");        /* dann * als Echo                 */
  283.  
  284.   else {            /* alle anderen Zeichen                 */
  285.     if (zeichen >= ' ' || zeichen == 0x07) /* druckbar oder BELL?         */
  286.       hputc(zeichen);        /* dann Echo                     */
  287.  
  288.     else {            /* sonstige Kontrolzeichen             */
  289.       hputc('^');        /* Prefix                     */
  290.       hputc(zeichen + '@');    /* Zeichen - druckbar gemacht             */
  291.       }
  292.     }
  293.   }
  294.  
  295. /*---------------------------------------------------------------------------*/
  296. VOID bliloe()            /* 1 Zeichen am Hostterminal loeschen         */
  297.   {
  298.   register char    zeichen;    /* Scratch                     */
  299.  
  300.   if ((zeichen = *(--blipoi)) != 0x07) { /* Sonderfall BELL             */
  301.     bputbs();            /* Zeichen loeschen                 */
  302.     if (zeichen < ' ') bputbs();/* Controlzeichen: Prefix + Zeichen loeschen */
  303.     }
  304.   else hputc(zeichen);        /* BELL wird wiederholt                 */
  305.  
  306.   --blicnt;            /* Zeilenlaenge -1                 */
  307.   }
  308.  
  309. /*---------------------------------------------------------------------------*/
  310. VOID hstcmd()            /* Befehl an Hostinterface ausfuehren         */
  311.   {
  312.   register char       *paspoi;    /* Pointer in Passwort (<ESC>-P)         */
  313.   register char       zeichen;    /* Scratch                     */
  314.   register unsigned arg;    /* Argument des Befehls                 */
  315.   unsigned cnt;            /* Scratch                     */
  316.  
  317.   skipsp(&blicnt, &blipoi);    /* Leerzeichen am Anfang uebergehen         */
  318.   if (blicnt != 0) {        /* ueberhaupt was da?                 */
  319.     zeichen = upcase(*blipoi++);/* Befehl - erstes Zeichen - holen         */
  320.     --blicnt;            /* ein Zeichen ist verbraucht             */
  321.  
  322.     skipsp(&blicnt, &blipoi);    /* Rest bis zum Argument ueberlesen         */
  323.     switch(zeichen) {
  324.  
  325. /*==============================*/
  326.       case 'C':            /* Host an TNC connecten             */
  327.         if (hstusr->conflg == 0 && hstmod == 0 ) 
  328.         { /* schon connected? Dann uebergehen         */
  329.           cpyid(hstusr->call, myid);    /* Host ist am TNC             */
  330.           hstcon();        /* an alle melden                 */
  331.         }
  332.         break;
  333.  
  334. /*==============================*/
  335.       case 'D':            /* Host vom TNC disconnecten             */
  336.         if (hstusr->conflg != 0 && hstmod == 0 ) 
  337.         { /* schon disconnected? Dann uebergehen    */
  338.           hstsen(1);        /* an alle melden, sofort alles senden         */
  339.           hstdis();        /* Interface trennen, melden             */
  340.         }
  341.         break;
  342.  
  343. /*==============================*/
  344.       case 'P':            /* Passwort zeigen-eingeben             */
  345.         if (blicnt == 0) {    /* ohne Argument = zeigen             */
  346.           bpromp();        /* neue Zeile, *                 */
  347.           paspoi = paswrd;    /* auf Anfang des Passwortes             */
  348.           for (cnt = 0; cnt < paswle; ++cnt)
  349.             bchout(*paspoi++);    /* Passwort ausgeben                 */
  350.           bende();        /* und * am Ende                 */
  351.           }
  352.  
  353.         else {            /* neues Passwort setzen             */
  354.           paspoi = paswrd;    /* auf Anfang Passwort                 */
  355.           paswle =        /* Laenge = 0                     */
  356.           cnt = 0;        /* eingegebene Zeichen = 0             */
  357.  
  358.           while (blicnt-- != 0) { /* Rest der Zeile ist Passwort         */
  359.             if ((zeichen = *blipoi++) != 0x0a) { /* Linefeed ueberlesen         */
  360.               if ((*paspoi++ = zeichen) != ' ') /* Leerzeichen zaehlen nicht */
  361.                 ++cnt;
  362.               ++paswle;
  363.               if (paswle == 80)
  364.                 break;        /* maximale Laenge erreicht?             */
  365.               }
  366.             }
  367.           if (cnt < 5)
  368.             paswle = 0;        /* Mindestlaenge muss eingehalten werden     */
  369.           }
  370.         break;
  371.  
  372. #ifndef MODIFIED
  373. /*==============================*/
  374.       case 'T':            /* Keyup Delay zeigen-eingeben             */
  375.         hstparm( &Tpar, 255 );
  376.         break;
  377.  
  378. /*==============================*/
  379.       case 'Y':            /* Connect zu Host erlaubt j-n             */
  380.         hstparm( &hostco, 1 );
  381.         break;
  382.  
  383. /*==============================*/
  384.       case 'F':            /* Full-Duplex j-n                 */
  385.         if (blicnt == 0)    /* ohne Argument = zeigen             */
  386.           bnuout(Dpar);
  387.  
  388.         else            /* mit Argument = setzen             */
  389.          {
  390.           if ((arg = nxtnum(&blicnt, &blipoi)) <= 1)    /* holen, testen     */
  391.            {
  392.             if ((Dpar == FALSE) && (arg == TRUE))
  393.              {                        /* Wechsel auf Full  */
  394.               DIinc();                    /* Interrupts aus    */
  395.               Dpar = TRUE;
  396.               pushtx();                    /* Sender anwerfen   */
  397.               decEI();                    /* Interrupts an     */
  398.              }
  399.             Dpar = arg;        /* ok, merken                     */
  400.            }
  401.           else
  402.             invcmd();        /* meckern                     */
  403.           }
  404.         break;
  405.  
  406. #ifdef KISSMODE
  407. /*==============================*/
  408.       case 'K':            /* Kiss or crosslink mode j-n             */
  409.         hstparm( &crlmod, 3 );
  410.         break;
  411. #endif
  412.  
  413. #ifdef HOSTMODE
  414. /*==============================*/
  415.       case 'H':            /* Host mode j-n             */
  416.         hstparm( &hstmod, 1 );
  417.         break;
  418. #endif
  419. #endif
  420.  
  421. /*==============================*/
  422.       default :            /* ungueltiger Befehl                 */
  423.         invcmd();        /* meckern                     */
  424.         break;
  425.  
  426.       }
  427.     }
  428.   }
  429.  
  430. /*--------------------------helper utility to hstcmd()-----------------------*/
  431. #ifdef MODIFIEDANDNEVERDOTHIS
  432. hstparm( variable, limit )
  433. unsigned char *variable;
  434. unsigned limit;
  435. {
  436.     register unsigned arg;
  437.  
  438.     if (blicnt == 0)    /* ohne Argument = zeigen             */
  439.         bnuout(*variable);
  440.     else 
  441.     {            /* mit Argument = setzen             */
  442.         if ((arg = nxtnum(&blicnt, &blipoi)) <= limit) /* holen, testen         */
  443.             *variable = arg;        /* ok, merken                     */
  444.         else
  445.             invcmd();        /* meckern                     */
  446.     }
  447. }
  448. #endif
  449.  
  450. /*---------------------------------------------------------------------------*/
  451. VOID hstcon()            /* Host wird connected                 */
  452.   {
  453.   bstrng("\015\012CONNECTED to ");
  454.   bcalou(hstusr->call);        /* Meldung mit Call und Bimmel             */
  455.   bbel();
  456.  
  457.   l2tol7(1, hstusr, 0);        /* nach unten melden: Usrtyp, ctrl-blk, cmd  */
  458.  
  459.   hstusr->conflg = 1;        /* Connect Flag setzen                 */
  460.   hstusr->noact2 = ininat;    /* no-activity-timeout neu setzen         */
  461.   }
  462.  
  463. /*---------------------------------------------------------------------------*/
  464. VOID hstdis()            /* Host wird disconnected             */
  465. {
  466.   dealml(& hstusr->inbuf);    /* Eingabebuffer freigeben             */
  467.   dealml(& hstusr->outbuf);    /* Ausgabebuffer freigeben             */
  468.   hstusr->inlin =        /* keine Zeile in Eingabe             */
  469.   hstusr->outlin = 0;        /* keine Zeile in Ausgabe             */
  470.  
  471.   bstrng("\015\012DISCONNECTED fm ");
  472.   bcalou(hstusr->call);        /* Meldung mit Call und Bimmel             */
  473.   bbel();
  474.  
  475.   l2tol7(2, hstusr, 0);        /* nach unten melden: Usrtyp, ctrl-blk, cmd  */
  476.  
  477.   hstusr->conflg =        /* Connect Flag ruecksetzen             */
  478.   hstusr->disflg = 0;        /* Abwurf ausgefuehrt markieren             */
  479. #ifdef HOSTMODE
  480.   if( hststs == 1 )
  481.     hststs = 4;
  482.   else if( hststs == 2 )
  483.   {
  484.       dropdcd();
  485.       hststs = 3;
  486.       hotout = 20;
  487.   }  
  488. #endif
  489. }
  490.  
  491. /*---------------------------------------------------------------------------*/
  492. VOID hstsen(conflg)        /* Host Sende Service                 */
  493. BOOLEAN conflg;            /* Congestion Flag, 0=normal, 1=alles sofort */
  494.   {
  495. register mhtyp    *mbhd;        /* Message Buffer Head der Info             */
  496.  
  497.   while (hstusr->inlin != 0)    /* solange Zeilen vorhanden             */
  498.     {
  499.       mbhd = (mhtyp *) hstusr->inbuf.lnext;    /* MBHD aufbauen         */
  500.       mbhd->l2lnk = (l2ltyp *) hstusr;    /* User ist Host             */
  501.       mbhd->usrtyp = 0;        /* Usertyp setzen                 */
  502.       if (! fmlink(conflg, mbhd)) /* Frame senden, Fehler dabei?         */
  503.         break;            /* im Fehlerfalle Abbruch             */
  504.       hstusr->inlin -=1;    /* eine Zeile erledigt                 */
  505.       hstusr->noact2 = ininat;    /* no-activity-timeout neu setzen         */
  506.     }
  507.   }
  508.  
  509. /*---------------------------------------------------------------------------*/
  510. VOID bcalou (call)              /* Call auf Crosslink Kanal geben         */
  511. char *call;
  512.  
  513.   {
  514.   register unsigned z_zahl;        /* Anzahl ausgegebener Zeichen          */
  515.   register char     ssid;        /* SSID des Calls             */
  516.   register char     zeichen;        /* aktuelles Zeichen             */
  517.  
  518.   for (z_zahl = 6; z_zahl != 0; --z_zahl)
  519.     {
  520.       zeichen = *call++;
  521.       if (zeichen != ' ') bchout(zeichen);
  522.     }
  523.   ssid = (*call >> 1) & 0x0f;
  524.   if (ssid)
  525.     {
  526.       hputc('-');
  527.       bnumou(ssid);
  528.     }
  529.   }
  530.  
  531. /*---------------------------------------------------------------------------*/
  532. VOID bnuout (zahl)              /* Zahl auf Crosslink Kanal geben         */
  533. int zahl;            /* eingerahmt in * *                 */
  534.  
  535.   {
  536.   bpromp();            /* neue Zeile, *                 */
  537.   bnumou(zahl);            /* Zahl                         */
  538.   bende();            /* und * am Ende                 */
  539.   }
  540.  
  541. /*---------------------------------------------------------------------------*/
  542. VOID bnumou (zahl)              /* Zahl auf Crosslink Kanal geben         */
  543. unsigned zahl;
  544.  
  545.   {
  546.   BOOLEAN  notnul;        /* fuehrende Null j/n                 */
  547.   register unsigned diviso;    /* Stellenwert der aktuellen Stelle         */
  548.   register unsigned ziffer;    /* aktuelle Ziffer                 */
  549.   register unsigned numcnt;    /* Zahl der ausgegebenen Ziffern         */
  550.  
  551.   notnul = FALSE;
  552.   diviso = 10000;
  553.   for(numcnt = 5; numcnt != 0; --numcnt) {
  554.     ziffer = zahl / diviso;
  555.     if ((ziffer != 0) || (notnul /*== TRUE*/) || (diviso == 1)) {
  556.       hputc (ziffer + '0');
  557.       notnul = TRUE;
  558.       }
  559.     zahl %= diviso;
  560.     diviso /= 10;
  561.     }
  562.   }
  563.  
  564. #ifdef PORTABLE
  565. /*---------------------------------------------------------------------------*/
  566. VOID bputbs()            /* Backspace an Hostterminal             */
  567.   {
  568.   bstrng("\010 \010");        /* Backspace soll destruktiv sein         */
  569.   }
  570.  
  571. /*---------------------------------------------------------------------------*/
  572. VOID invcmd()            /* ungueltigen Befehl melden             */
  573.   {
  574.   bstrng("* INVALID COMMAND *\007\015\012");
  575.   }
  576.  
  577. /*---------------------------------------------------------------------------*/
  578. VOID bpromp()                   /* Prompt auf Crosslink Kanal             */
  579.   {
  580.   bstrng("* ");
  581.   }
  582.  
  583. /*---------------------------------------------------------------------------*/
  584. VOID bende()                    /* Ende Kennung auf Crosslink Kanal         */
  585.   {
  586.   bstrng(" *\015\012");
  587.   }
  588.  
  589. /*---------------------------------------------------------------------------*/
  590. VOID bbel()                     /* BELL Ausgabe auf Crosslink Kanal         */
  591.   {
  592.   bstrng("\015\012\007");
  593.   }
  594.  
  595. #else
  596.  
  597. #asm
  598.     .z80
  599.     public    invcmd_, bpromp_, bende_, bbel_, bputbs_
  600.     extrn    bstrng_
  601.  
  602. bputbs_:  ld    hl,bputbs
  603.       jr    bbelx
  604. invcmd_:  ld    hl,invcmds
  605.       jr    bbelx
  606. bpromp_:  ld    hl,bpromps
  607.       jr    bbelx
  608. bende_:      ld    hl,bendes
  609.       jr    bbelx
  610. bbel_:    ld    hl,bbels
  611. bbelx:      push    hl
  612.       call    bstrng_
  613.       pop    hl
  614.       ret
  615.  
  616. invcmds:  db    '* INVALID COMMAND *'
  617. bbels:      db    13,10,7,0
  618. bpromps:  db    '*',' ',0
  619. bendes:   db    ' ','*',13,10,0
  620. bputbs:   db    8,' ',8,0
  621.  
  622.     .8080
  623. #endasm
  624.  
  625. #endif
  626.  
  627. /*---------------------------------------------------------------------------*/
  628. VOID bstrng (string)            /* String auf Crossllink Kanal geben         */
  629. register char *string;
  630.   {
  631.   while (*string != 0) hputc(*string++);
  632.   }
  633.  
  634. /*---------------------------------------------------------------------------*/
  635. VOID bchout (c)                 /* Zeichen auf Crosslink Kanal geben         */
  636. register char c;
  637.   {
  638.   if (c >= ' ') hputc(c);
  639.   else {
  640.     hputc('^');
  641.     hputc(c + '@');
  642.     }
  643.   }
  644.  
  645. /*---------------------------------------------------------------------------*/
  646. BOOLEAN iswarm ()                   /* Test auf Warmstart             */
  647.   {
  648.   return (magicn == MAGIC);    /* RAM noch intakt? dann Warmstart         */
  649.   }
  650.  
  651. /*---------------------------------------------------------------------------*/
  652. #ifdef HOSTMODE
  653.  
  654. VOID hstmodsv()
  655. {
  656.     switch( hststs )
  657.     {
  658.         case 5:
  659.             if( hstusr->conflg == 0 )
  660.             {
  661.                 cpyid( hstusr->call, myid );
  662.                 hstcon();
  663.                 hststs = 2;
  664.             }
  665.             else
  666.             {
  667.                 bstrng("\015\013TNC Busy.");
  668.                 hststs = 3;
  669.             }
  670.             break;
  671.         case 6:
  672.             dropdcd();
  673.             hststs = 3;
  674.             hotout = 20;
  675.             break;
  676.         case 7:
  677.             if( hstusr-> conflg )
  678.             {
  679.                 hstsen( 1 );
  680.                 hstdis();
  681.             }
  682.             dropdcd();
  683.             hststs = 0;
  684.     }
  685. }
  686. #endif
  687.  
  688. /*--- Ende Level 7c ---------------------------------------------------------*/
  689.  
  690.